home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 February: Tool Chest / Dev.CD Feb 95 / Dev.CD Feb 95.toast / New System Software Extensions / File System Manager SDK / Interfaces / FSM.p < prev   
Encoding:
Text File  |  1994-09-06  |  31.9 KB  |  886 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        FSM.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    File System Manager Software Development Kit, Thursday, September 1, 1994 2:43:02 PM
  8.  
  9.      Note:        For use with Universal Interfaces 2.0a1.  ETO #15, MPW prerelease.
  10.                 Future releases of Universal Interfaces will include this file.
  11.  
  12.      Bugs?:        If you find a problem with this file, send the file and version
  13.                  information (from above) and the problem description to:
  14.  
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT FSM;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __FSM__}
  30. {$SETC __FSM__ := 1}
  31.  
  32. {$I+}
  33. {$SETC FSMIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __FILES__}
  38. {$I Files.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43. {    OSUtils.p                                                    }
  44.  
  45. {$PUSH}
  46. {$ALIGN MAC68K}
  47. {$LibExport+}
  48.  
  49. CONST
  50. {    The new volume mount flags }
  51.     volMountInteractBit            = 15;                            { Input to VolumeMount: If set, it's OK for the file system }
  52.     volMountInteractMask        = $8000;                        { to perform user interaction to mount the volume }
  53.     volMountChangedBit            = 14;                            { Output from VoumeMount: If set, the volume was mounted, but }
  54.     volMountChangedMask            = $4000;                        { the volume mounting information record needs to be updated. }
  55.     volMountFSReservedMask        = $00ff;                        { bits 0-7 are defined by each file system for its own use }
  56.     volMountSysReservedMask        = $ff00;                        { bits 8-15 are reserved for Apple system use }
  57.  
  58. {
  59.  * The new volume mount info record
  60.  }
  61.  
  62. TYPE
  63.     VolumeMountInfoHeader = RECORD
  64.         length:                    INTEGER;                                { length of location data (including self) }
  65.         media:                    VolumeType;                                { type of media (must be registered with Apple) }
  66.         flags:                    INTEGER;                                { volume mount flags. Variable length data follows }
  67.     END;
  68.     VolumeMountInfoHeaderPtr = ^VolumeMountInfoHeader;
  69.  
  70.  
  71. CONST
  72.     gestaltFSMVersion            = 'fsm ';
  73.  
  74.     
  75. TYPE
  76. VCBPtr = ^VCB;
  77.  
  78. {
  79.  * Miscellaneous file system values not in Files.h
  80.  }
  81.  
  82. CONST
  83.     fsUsrCNID                    = 16;                            { First assignable directory or file number }
  84. {    File system trap word attribute bits }
  85.     kHFSBit                        = 9;                            { HFS call: bit 9 }
  86.     kHFSMask                    = $0200;
  87.     kAsyncBit                    = 10;                            { Asynchronous call: bit 10 }
  88.     kAsyncMask                    = $0400;
  89.  
  90. {
  91.  * HFSCIProc selectCode values
  92.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  93.  * may be set in these selectCode values.
  94.  }
  95.     kFSMOpen                    = $A000;
  96.     kFSMClose                    = $A001;
  97.     kFSMRead                    = $A002;
  98.     kFSMWrite                    = $A003;
  99.     kFSMGetVolInfo                = $A007;
  100.     kFSMCreate                    = $A008;
  101.     kFSMDelete                    = $A009;
  102.     kFSMOpenRF                    = $A00A;
  103.     kFSMRename                    = $A00B;
  104.     kFSMGetFileInfo                = $A00C;
  105.     kFSMSetFileInfo                = $A00D;
  106.     kFSMUnmountVol                = $A00E;
  107.     kFSMMountVol                = $A00F;
  108.     kFSMAllocate                = $A010;
  109.     kFSMGetEOF                    = $A011;
  110.     kFSMSetEOF                    = $A012;
  111.     kFSMFlushVol                = $A013;
  112.     kFSMGetVol                    = $A014;
  113.     kFSMSetVol                    = $A015;
  114.     kFSMEject                    = $A017;
  115.     kFSMGetFPos                    = $A018;
  116.     kFSMOffline                    = $A035;
  117.     kFSMSetFilLock                = $A041;
  118.     kFSMRstFilLock                = $A042;
  119.     kFSMSetFilType                = $A043;
  120.     kFSMSetFPos                    = $A044;
  121.     kFSMFlushFile                = $A045;
  122. {    The File System HFSDispatch selectCodes }
  123.     kFSMOpenWD                    = $0001;
  124.     kFSMCloseWD                    = $0002;
  125.     kFSMCatMove                    = $0005;
  126.     kFSMDirCreate                = $0006;
  127.     kFSMGetWDInfo                = $0007;
  128.     kFSMGetFCBInfo                = $0008;
  129.     kFSMGetCatInfo                = $0009;
  130.     kFSMSetCatInfo                = $000A;
  131.     kFSMSetVolInfo                = $000B;
  132.     kFSMLockRng                    = $0010;
  133.     kFSMUnlockRng                = $0011;
  134.     kFSMCreateFileIDRef            = $0014;
  135.     kFSMDeleteFileIDRef            = $0015;
  136.     kFSMResolveFileIDRef        = $0016;
  137.     kFSMExchangeFiles            = $0017;
  138.     kFSMCatSearch                = $0018;
  139.     kFSMOpenDF                    = $001A;
  140.     kFSMMakeFSSpec                = $001B;
  141. {    The Desktop Manager HFSDispatch selectCodes }
  142.     kFSMDTGetPath                = $0020;
  143.     kFSMDTCloseDown                = $0021;
  144.     kFSMDTAddIcon                = $0022;
  145.     kFSMDTGetIcon                = $0023;
  146.     kFSMDTGetIconInfo            = $0024;
  147.     kFSMDTAddAPPL                = $0025;
  148.     kFSMDTRemoveAPPL            = $0026;
  149.     kFSMDTGetAPPL                = $0027;
  150.     kFSMDTSetComment            = $0028;
  151.     kFSMDTRemoveComment            = $0029;
  152.     kFSMDTGetComment            = $002A;
  153.     kFSMDTFlush                    = $002B;
  154.     kFSMDTReset                    = $002C;
  155.     kFSMDTGetInfo                = $002D;
  156.     kFSMDTOpenInform            = $002E;
  157.     kFSMDTDelete                = $002F;
  158. {    The AppleShare HFSDispatch selectCodes }
  159.     kFSMGetVolParms                = $0030;
  160.     kFSMGetLogInInfo            = $0031;
  161.     kFSMGetDirAccess            = $0032;
  162.     kFSMSetDirAccess            = $0033;
  163.     kFSMMapID                    = $0034;
  164.     kFSMMapName                    = $0035;
  165.     kFSMCopyFile                = $0036;
  166.     kFSMMoveRename                = $0037;
  167.     kFSMOpenDeny                = $0038;
  168.     kFSMOpenRFDeny                = $0039;
  169.     kFSMGetXCatInfo                = $003A;
  170.     kFSMGetVolMountInfoSize        = $003F;
  171.     kFSMGetVolMountInfo            = $0040;
  172.     kFSMVolumeMount                = $0041;
  173.     kFSMShare                    = $0042;
  174.     kFSMUnShare                    = $0043;
  175.     kFSMGetUGEntry                = $0044;
  176.     kFSMGetForeignPrivs            = $0060;
  177.     kFSMSetForeignPrivs            = $0061;
  178.  
  179. {
  180.  * UTDetermineVol status values
  181.  }
  182.     dtmvError                    = 0;                            { param error }
  183.     dtmvFullPathame                = 1;                            { determined by full pathname }
  184.     dtmvVRefNum                    = 2;                            { determined by volume refNum }
  185.     dtmvWDRefNum                = 3;                            { determined by working directory refNum }
  186.     dtmvDriveNum                = 4;                            { determined by drive number }
  187.     dtmvDefault                    = 5;                            { determined by default volume }
  188.  
  189. {
  190.  * UTGetBlock options
  191.  }
  192.     gbDefault                    = 0;                            { default value - read if not found }
  193. {    bits and masks }
  194.     gbReadBit                    = 0;                            { read block from disk (forced read) }
  195.     gbReadMask                    = $0001;
  196.     gbExistBit                    = 1;                            { get existing cache block }
  197.     gbExistMask                    = $0002;
  198.     gbNoReadBit                    = 2;                            { don't read block from disk if not found in cache }
  199.     gbNoReadMask                = $0004;
  200.     gbReleaseBit                = 3;                            { release block immediately after GetBlock }
  201.     gbReleaseMask                = $0008;
  202.  
  203. {
  204.  * UTReleaseBlock options
  205.  }
  206.     rbDefault                    = 0;                            { default value - just mark the buffer not in-use }
  207. {    bits and masks }
  208.     rbWriteBit                    = 0;                            { force write buffer to disk }
  209.     rbWriteMask                    = $0001;
  210.     rbTrashBit                    = 1;                            { trash buffer contents after release }
  211.     rbTrashMask                    = $0002;
  212.     rbDirtyBit                    = 2;                            { mark buffer dirty }
  213.     rbDirtyMask                    = $0004;
  214.     rbFreeBit                    = 3;                            { free the buffer (save in the hash) }
  215. {
  216.  *    rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache;
  217.  *    on >= System 7.0, rbfreeMask overrides rbTrash
  218.  }
  219.     rbFreeMask                    = $000A;
  220.  
  221. {
  222.  * UTFlushCache options
  223.  }
  224.     fcDefault                    = 0;                            { default value - just flush any dirty buffers }
  225. {    bits and masks }
  226.     fcTrashBit                    = 1;                            { trash buffers after flushing }
  227.     fcTrashMask                    = $0002;
  228.     fcFreeBit                    = 3;                            { free buffers after flushing }
  229.     fcFreeMask                    = $0008;                        { fcFreeMask works as fcTrash on < System 7.0 RamCache }
  230.  
  231. {
  232.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  233.  }
  234.     noCacheBit                    = 5;                            { don't cache this please }
  235.     noCacheMask                    = $0020;
  236.     rdVerifyBit                    = 6;                            { read verify }
  237.     rdVerifyMask                = $0040;
  238.  
  239. {
  240.  * Cache routine internal error codes
  241.  }
  242.     chNoBuf                        = 1;                            { no free cache buffers (all in use) }
  243.     chInUse                        = 2;                            { requested block in use }
  244.     chnotfound                    = 3;                            { requested block not found }
  245.     chNotInUse                    = 4;                            { block being released was not in use }
  246.  
  247. {
  248.  * FCBRec.fcbFlags bits
  249.  }
  250.     fcbWriteBit                    = 0;                            { Data can be written to this file }
  251.     fcbWriteMask                = $01;
  252.     fcbResourceBit                = 1;                            { This file is a resource fork }
  253.     fcbResourceMask                = $02;
  254.     fcbWriteLockedBit            = 2;                            { File has a locked byte range }
  255.     fcbWriteLockedMask            = $04;
  256.     fcbSharedWriteBit            = 4;                            { File is open for shared write access }
  257.     fcbSharedWriteMask            = $10;
  258.     fcbFileLockedBit            = 5;                            { File is locked (write-protected) }
  259.     fcbFileLockedMask            = $20;
  260.     fcbOwnClumpBit                = 6;                            { File has clump size specified in FCB }
  261.     fcbOwnClumpMask                = $40;
  262.     fcbModifiedBit                = 7;                            { File has changed since it was last flushed }
  263.     fcbModifiedMask                = $80;
  264.  
  265. {
  266.  * ExtFileProc options
  267.  }
  268.     extendFileAllBit            = 0;                            { allocate all requested bytes or none }
  269.     extendFileAllMask            = $0001;
  270.     extendFileContigBit            = 1;                            { force contiguous allocation }
  271.     extendFileContigMask        = $0002;
  272.  
  273. {
  274.  *    HFS Component Interface constants
  275.  }
  276. {
  277.  * compInterfMask bits specific to HFS component
  278.  }
  279.     hfsCIDoesHFSBit                = 23;                            { set if file system supports HFS calls }
  280.     hfsCIDoesHFSMask            = $00800000;
  281.     hfsCIDoesAppleShareBit        = 22;                            { set if AppleShare calls supported }
  282.     hfsCIDoesAppleShareMask        = $00400000;
  283.     hfsCIDoesDeskTopBit            = 21;                            { set if Desktop Database calls supported }
  284.     hfsCIDoesDeskTopMask        = $00200000;
  285.     hfsCIDoesDynamicLoadBit        = 20;                            { set if dynamically loading code resource }
  286.     hfsCIDoesDynamicLoadMask    = $00100000;                    {        supported }
  287.     hfsCIResourceLoadedBit        = 19;                            { set if code resource already loaded }
  288.     hfsCIResourceLoadedMask        = $00080000;
  289.     hfsCIHasHLL2PProcBit        = 18;                            { set if FFS' log2PhyProc and Extendfile proc }
  290.     hfsCIHasHLL2PProcMask        = $00040000;                    { is written in a high level language. (i.e., uses Pascal calling convention) }
  291.  
  292. {
  293.  *    Disk Initialization Component Interface constants
  294.  }
  295. {
  296.  * compInterfMask bits specific to Disk Initialization component
  297.  }
  298.     diCIHasExtFormatParamsBit    = 18;                            { set if file system needs extended format }
  299.     diCIHasExtFormatParamsMask    = $00040000;                    {        parameters }
  300.     diCIHasMultiVolTypesBit        = 17;                            { set if file system supports more than one }
  301.     diCIHasMultiVolTypesMask    = $00020000;                    {        volume type }
  302.     diCIDoesSparingBit            = 16;                            { set if file system supports disk sparing }
  303.     diCIDoesSparingMask            = $00010000;
  304.     diCILiveBit                    = 0;                            { set if file system is candidate for current }
  305.     diCILiveMask                = $00000001;                    {        formatting operation (set by PACK2) }
  306.  
  307. {
  308.  * Disk Initialization Component Function selectors
  309.  }
  310.     diCILoad                    = 1;                            { Make initialization code memory resident }
  311.     diCIUnload                    = 2;                            { Make initialization code purgeable }
  312.     diCIEvaluateSizeChoices        = 3;                            { Evaluate size choices }
  313.     diCIExtendedZero            = 4;                            { Write an empty volume directory }
  314.     diCIValidateVolName            = 5;                            { Validate volume name }
  315.     diCIGetVolTypeInfo            = 6;                            { get volume type info }
  316.     diCIGetFormatString            = 7;                            { get dialog format string }
  317.     diCIGetExtFormatParams        = 8;                            { get extended format parameters }
  318.     diCIGetDefectList            = 9;                            { return the defect list for the indicated disk - reserved for future use }
  319.  
  320. {
  321.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  322.  }
  323.     diCIFmtListMax                = 8;                            { maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries }
  324. {    bits in FormatListRec.formatFlags: }
  325.     diCIFmtFlagsValidBit        = 7;                            { set if sec, side, tracks valid }
  326.     diCIFmtFlagsValidMask        = $80;
  327.     diCIFmtFlagsCurrentBit        = 6;                            { set if current disk has this fmt }
  328.     diCIFmtFlagsCurrentMask        = $40;
  329. {    bits in FormatListRec.sizeListFlags: }
  330.     diCISizeListOKBit            = 15;                            { set if this disk size usable }
  331.     diCISizeListOKMask            = $8000;
  332.  
  333. {
  334.  * DICIGetFormatStringRec.stringKind format strings
  335.  }
  336.     diCIAlternateFormatStr        = 1;                            { get alternate format  string (Balloon Help) }
  337.     diCISizePresentationStr        = 2;                            { get size presentation string (for dialog) }
  338.  
  339. {
  340.  * Error codes returned by Disk Sparing
  341.  }
  342.     diCIUserCancelErr            = 1;                            { user cancelled the disk init }
  343.     diCICriticalSectorBadErr    = 20;                            { critical sectors are bad (hopeless)    }
  344.     diCISparingFailedErr        = 21;                            { disk cannot be spared }
  345.     diCITooManyBadSectorsErr    = 22;                            { too many bad sectors }
  346.     diCIUnknownVolTypeErr        = 23;                            { the volume type passed in diCIExtendedZero paramBlock is not supported }
  347.     diCIVolSizeMismatchErr        = 24;                            { specified volume size doesn’t match with formatted disk size }
  348.     diCIUnknownDICallErr        = 25;                            { bogus DI function call selector }
  349.     diCINoSparingErr            = 26;                            { disk is bad but the target FS doesn't do disk sparing }
  350.     diCINoExtendInfoErr            = 27;                            { missing file system specific extra parameter in diCIExtendedZero call }
  351.     diCINoMessageTextErr        = 28;                            { missing message text in DIReformat call }
  352.  
  353. {
  354.  *    File System Manager constants
  355.  }
  356. {
  357.  * Miscellaneous constants used by FSM
  358.  }
  359.     fsdVersion1                    = 1;                            { current version of FSD record }
  360.     fsmIgnoreFSID                = $fffe;                        { this FSID should be ignored by the driver }
  361.     fsmGenericFSID                = $ffff;                        { unknown foreign file system ID }
  362.  
  363. {
  364.  * compInterfMask bits common to all FSM components
  365.  }
  366.     fsmComponentEnableBit        = 31;                            { set if FSM component interface is enabled }
  367.     fsmComponentEnableMask        = $80000000;
  368.     fsmComponentBusyBit            = 30;                            { set if FSM component interface is busy }
  369.     fsmComponentBusyMask        = $40000000;
  370.  
  371. {
  372.  * Selectors for GetFSInfo
  373.  }
  374.     fsmGetFSInfoByIndex            = -1;                            { get fs info by index }
  375.     fsmGetFSInfoByFSID            = 0;                            { get fs info by FSID }
  376.     fsmGetFSInfoByRefNum        = 1;                            { get fs info by file/vol refnum }
  377.  
  378. {
  379.  * InformFSM messages
  380.  }
  381.     fsmNopMessage                = 0;                            { nop }
  382.     fsmDrvQElChangedMessage        = 1;                            { DQE has changed }
  383.     fsmGetFSIconMessage            = 2;                            { Get FFS's disk icon }
  384.  
  385. {
  386.  * Messages passed to the fileSystemCommProc
  387.  }
  388.     ffsNopMessage                = 0;                            { nop, should always return noErr }
  389.     ffsGetIconMessage            = 1;                            { return disk icon and mask }
  390.     ffsIDDiskMessage            = 2;                            { identify the about-to-be-mounted volume }
  391.     ffsLoadMessage                = 3;                            { load in the FFS }
  392.     ffsUnloadMessage            = 4;                            { unload the FFS }
  393.     ffsIDVolMountMessage        = 5;                            { identify a VolMountInfo record }
  394.     ffsInformMessage            = 6;                            { FFS defined message }
  395.     ffsGetIconInfoMessage        = 7;
  396.  
  397. {
  398.  * Error codes from FSM functions
  399.  }
  400.     fsmFFSNotFoundErr            = -431;                            { Foreign File system does not exist - new Pack2 could return this error too }
  401.     fsmBusyFFSErr                = -432;                            { File system is busy, cannot be removed }
  402.     fsmBadFFSNameErr            = -433;                            { Name length not 1 <= length <= 31 }
  403.     fsmBadFSDLenErr                = -434;                            { FSD size incompatible with current FSM vers }
  404.     fsmDuplicateFSIDErr            = -435;                            { FSID already exists on InstallFS }
  405.     fsmBadFSDVersionErr            = -436;                            { FSM version incompatible with FSD }
  406.     fsmNoAlternateStackErr        = -437;                            { no alternate stack for HFS CI }
  407.     fsmUnknownFSMMessageErr        = -438;                            { unknown message passed to FSM }
  408.  
  409. {
  410.  *    HFS Utility routine records
  411.  }
  412. {
  413.  * record used by UTGetPathComponentName
  414.  }
  415.  
  416. TYPE
  417.     ParsePathRec = RECORD
  418.         namePtr:                StringPtr;                                { pathname to parse }
  419.         startOffset:            INTEGER;                                { where to start parsing }
  420.         componentLength:        INTEGER;                                { the length of the pathname component parsed }
  421.         moreName:                SignedByte;                                { non-zero if there are more components after this one }
  422.         foundDelimiter:            SignedByte;                                { non-zero if parsing stopped because a colon (:) delimiter was found }
  423.     END;
  424.     ParsePathRecPtr = ^ParsePathRec;
  425.  
  426.     WDCBRec = RECORD
  427.         wdVCBPtr:                VCBPtr;                                    { Pointer to VCB of this working directory }
  428.         wdDirID:                LONGINT;                                { Directory ID number of this working directory }
  429.         wdCatHint:                LONGINT;                                { Hint for finding this working directory }
  430.         wdProcID:                LONGINT;                                { Process that created this working directory }
  431.     END;
  432.     WDCBRecPtr = ^WDCBRec;
  433.  
  434.     FCBRec = RECORD
  435.         fcbFlNm:                LONGINT;                                { FCB file number. Non-zero marks FCB used }
  436.         fcbFlags:                SignedByte;                                { FCB flags }
  437.         fcbTypByt:                SignedByte;                                { File type byte }
  438.         fcbSBlk:                INTEGER;                                { File start block (in alloc size blks) }
  439.         fcbEOF:                    LONGINT;                                { Logical length or EOF in bytes }
  440.         fcbPLen:                LONGINT;                                { Physical file length in bytes }
  441.         fcbCrPs:                LONGINT;                                { Current position within file }
  442.         fcbVPtr:                VCBPtr;                                    { Pointer to the corresponding VCB }
  443.         fcbBfAdr:                Ptr;                                    { File's buffer address }
  444.         fcbFlPos:                INTEGER;                                { Directory block this file is in }
  445.         { FCB Extensions for HFS }
  446.         fcbClmpSize:            LONGINT;                                { Number of bytes per clump }
  447.         fcbBTCBPtr:                Ptr;                                    { Pointer to B*-Tree control block for file }
  448.         fcbExtRec:                ARRAY [0..2] OF LONGINT;                { First 3 file extents }
  449.         fcbFType:                OSType;                                    { File's 4 Finder Type bytes }
  450.         fcbCatPos:                LONGINT;                                { Catalog hint for use on Close }
  451.         fcbDirID:                LONGINT;                                { Parent Directory ID }
  452.         fcbCName:                Str31;                                    { CName of open file }
  453.     END;
  454.     FCBRecPtr = ^FCBRec;
  455.  
  456. {
  457.  *    HFS Component Interface records
  458.  }
  459.     Lg2PhysProcPtr = ProcPtr;  { FUNCTION Lg2Phys(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT): OSErr; }
  460.     Lg2PhysUPP = UniversalProcPtr;
  461.  
  462. CONST
  463.     uppLg2PhysProcInfo = $003FEFE0; { FUNCTION (4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param): 2 byte result; }
  464.  
  465. FUNCTION NewLg2PhysProc(userRoutine: Lg2PhysProcPtr): Lg2PhysUPP;
  466.     {$IFC NOT GENERATINGCFM }
  467.     INLINE $2E9F;
  468.     {$ENDC}
  469.  
  470. FUNCTION CallLg2PhysProc(fsdGlobalPtr: UNIV Ptr; volCtrlBlockPtr: VCBPtr; fileCtrlBlockPtr: FCBRecPtr; fileRefNum: INTEGER; filePosition: LONGINT; reqCount: LONGINT; VAR volOffset: LONGINT; VAR contiguousBytes: LONGINT; userRoutine: Lg2PhysUPP): OSErr;
  471.     {$IFC NOT GENERATINGCFM}
  472.     INLINE $205F, $4E90;
  473.     {$ENDC}
  474. TYPE
  475.     HFSCIProcPtr = ProcPtr;  { FUNCTION HFSCI(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER): OSErr; }
  476.     HFSCIUPP = UniversalProcPtr;
  477.  
  478. CONST
  479.     uppHFSCIProcInfo = $0000BEE0; { FUNCTION (4 byte param, 2 byte param, 4 byte param, 4 byte param, 2 byte param): 2 byte result; }
  480.  
  481. FUNCTION NewHFSCIProc(userRoutine: HFSCIProcPtr): HFSCIUPP;
  482.     {$IFC NOT GENERATINGCFM }
  483.     INLINE $2E9F;
  484.     {$ENDC}
  485.  
  486. FUNCTION CallHFSCIProc(theVCB: VCBPtr; selectCode: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; fsid: INTEGER; userRoutine: HFSCIUPP): OSErr;
  487.     {$IFC NOT GENERATINGCFM}
  488.     INLINE $205F, $4E90;
  489.     {$ENDC}
  490.  
  491. TYPE
  492.     HFSCIRec = RECORD
  493.         compInterfMask:            LONGINT;                                { component flags }
  494.         compInterfProc:            HFSCIUPP;                                { pointer to file system call processing code }
  495.         log2PhyProc:            Lg2PhysUPP;                                { pointer to Lg2PhysProc() code }
  496.         stackTop:                Ptr;                                    { file system stack top }
  497.         stackSize:                LONGINT;                                { file system stack size }
  498.         stackPtr:                Ptr;                                    { current file system stack pointer }
  499.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  500.         idSector:                LONGINT;                                { Sector you need to ID a local volume. For networked volumes, this must be -1 }
  501.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  502.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  503.     END;
  504.     HFSCIRecPtr = ^HFSCIRec;
  505.  
  506. {
  507.  *    Disk Initialization Component Interface records
  508.  }
  509.     DICIProcPtr = ProcPtr;  { FUNCTION DICI(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr): OSErr; }
  510.     DICIUPP = UniversalProcPtr;
  511.  
  512. CONST
  513.     uppDICIProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  514.  
  515. FUNCTION NewDICIProc(userRoutine: DICIProcPtr): DICIUPP;
  516.     {$IFC NOT GENERATINGCFM }
  517.     INLINE $2E9F;
  518.     {$ENDC}
  519.  
  520. FUNCTION CallDICIProc(whatFunction: INTEGER; paramBlock: UNIV Ptr; fsdGlobalPtr: UNIV Ptr; userRoutine: DICIUPP): OSErr;
  521.     {$IFC NOT GENERATINGCFM}
  522.     INLINE $205F, $4E90;
  523.     {$ENDC}
  524.  
  525. TYPE
  526.     DICIRec = RECORD
  527.         compInterfMask:            LONGINT;                                { component flags }
  528.         compInterfProc:            DICIUPP;                                { pointer to call processing code }
  529.         maxVolNameLength:        INTEGER;                                { maximum length of your volume name }
  530.         blockSize:                INTEGER;                                { your file system's block size }
  531.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  532.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  533.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  534.     END;
  535.     DICIRecPtr = ^DICIRec;
  536.  
  537. {
  538.  * FormatListRec as returned by the .Sony disk driver's
  539.  * Return Format List status call (csCode = 6).
  540.  * If the status call to get this list for a drive is not
  541.  * implemented by the driver, then a list with one entry
  542.  * is contructed from the drive queue element for the drive.
  543.  }
  544.     FormatListRec = RECORD
  545.         volSize:                LONGINT;                                { disk capacity in SECTORs }
  546.         formatFlags:            SignedByte;                                { flags }
  547.         sectorsPerTrack:        SignedByte;                                { sectors per track side }
  548.         tracks:                    INTEGER;                                { number of tracks }
  549.     END;
  550.     FormatListRecPtr = ^FormatListRec;
  551.  
  552. {
  553.  * SizeListRec built from FormatListRecs as described above.
  554.  }
  555.     SizeListRec = RECORD
  556.         sizeListFlags:            INTEGER;                                { flags as set by external file system }
  557.         sizeEntry:                FormatListRec;                            { disk driver format list record }
  558.     END;
  559.     SizeListRecPtr = ^SizeListRec;
  560.  
  561. {
  562.  * paramBlock for the diCIEvaluateSize call
  563.  }
  564.     DICIEvaluateSizeRec = RECORD
  565.         defaultSizeIndex:        INTEGER;                                { default size for this FS }
  566.         numSizeEntries:            INTEGER;                                { number of size entries }
  567.         driveNumber:            INTEGER;                                { drive number }
  568.         sizeListPtr:            SizeListRecPtr;                            { ptr to size entry table }
  569.         sectorSize:                INTEGER;                                { bytes per sector }
  570.     END;
  571.     DICIEvaluateSizeRecPtr = ^DICIEvaluateSizeRec;
  572.  
  573. {
  574.  * paramBlock for the diCIExtendedZero call
  575.  }
  576.     DICIExtendedZeroRec = RECORD
  577.         driveNumber:            INTEGER;                                { drive number }
  578.         volNamePtr:                StringPtr;                                { ptr to volume name string }
  579.         fsid:                    INTEGER;                                { file system ID }
  580.         volTypeSelector:        INTEGER;                                { volume type selector, if supports more than 1 type }
  581.         numDefectBlocks:        INTEGER;                                { number of bad logical blocks }
  582.         defectListSize:            INTEGER;                                { size of the defect list buffer in bytes }
  583.         defectListPtr:            Ptr;                                    { pointer to defect list buffer }
  584.         volSize:                LONGINT;                                { size of volume in SECTORs }
  585.         sectorSize:                INTEGER;                                { bytes per sector }
  586.         extendedInfoPtr:        Ptr;                                    { ptr to extended info }
  587.     END;
  588.     DICIExtendedZeroRecPtr = ^DICIExtendedZeroRec;
  589.  
  590. {
  591.  * paramBlock for the diCIValidateVolName call
  592.  }
  593.     DICIValidateVolNameRec = RECORD
  594.         theChar:                CHAR;                                    { the character to validate }
  595.         hasMessageBuffer:        BOOLEAN;                                { false if no message }
  596.         charOffset:                INTEGER;                                { position of the current character (first char = 1) }
  597.         messageBufferPtr:        StringPtr;                                { pointer to message buffer or nil }
  598.         charByteType:            INTEGER;                                { theChar's byte type (smSingleByte, smFirstByte, or smLastByte) }
  599.     END;
  600.     DICIValidateVolNameRecPtr = ^DICIValidateVolNameRec;
  601.  
  602. {
  603.  * paramBlock for the diCIGetVolTypeInfo call
  604.  }
  605.     DICIGetVolTypeInfoRec = RECORD
  606.         volSize:                LONGINT;                                { size of volume in SECTORs }
  607.         sectorSize:                INTEGER;                                { bytes per sector }
  608.         numVolTypes:            INTEGER;                                { number of volume types supported }
  609.         volTypesBuffer:            ARRAY [0..3] OF Str32;                    { 4 string buffers }
  610.     END;
  611.     DICIGetVolTypeInfoRecPtr = ^DICIGetVolTypeInfoRec;
  612.  
  613. {
  614.  * paramBlock for the diCIGetFormatString call
  615.  }
  616.     DICIGetFormatStringRec = RECORD
  617.         volSize:                LONGINT;                                { volume size in SECTORs }
  618.         sectorSize:                INTEGER;                                { sector size }
  619.         volTypeSelector:        INTEGER;                                { volume type selector }
  620.         stringKind:                INTEGER;                                { sub-function = type of string }
  621.         stringBuffer:            Str255;                                    { string buffer }
  622.     END;
  623.     DICIGetFormatStringRecPtr = ^DICIGetFormatStringRec;
  624.  
  625. {
  626.  * paramBlock for the diCIGetExtendedFormatParams call
  627.  }
  628.     DICIGetExtendedFormatRec = RECORD
  629.         driveNumber:            INTEGER;                                { drive number }
  630.         volTypeSelector:        INTEGER;                                { volume type selector or 0 }
  631.         volSize:                LONGINT;                                { size of volume in SECTORs }
  632.         sectorSize:                INTEGER;                                { bytes per sector }
  633.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to the foreign file system's FSSpec }
  634.         extendedInfoPtr:        Ptr;                                    { pointer to extended parameter structure }
  635.     END;
  636.     DICIGetExtendedFormatRecPtr = ^DICIGetExtendedFormatRec;
  637.  
  638. {
  639.  *    File System Manager records
  640.  }
  641.     FSDCommProcPtr = ProcPtr;  { FUNCTION FSDComm(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr): OSErr; }
  642.     FSDCommUPP = UniversalProcPtr;
  643.  
  644. CONST
  645.     uppFSDCommProcInfo = $00000FA0; { FUNCTION (2 byte param, 4 byte param, 4 byte param): 2 byte result; }
  646.  
  647. FUNCTION NewFSDCommProc(userRoutine: FSDCommProcPtr): FSDCommUPP;
  648.     {$IFC NOT GENERATINGCFM }
  649.     INLINE $2E9F;
  650.     {$ENDC}
  651.  
  652. FUNCTION CallFSDCommProc(message: INTEGER; paramBlock: UNIV Ptr; globalsPtr: UNIV Ptr; userRoutine: FSDCommUPP): OSErr;
  653.     {$IFC NOT GENERATINGCFM}
  654.     INLINE $205F, $4E90;
  655.     {$ENDC}
  656.  
  657. TYPE
  658.     FSDRec = RECORD
  659.         fsdLink:                ^FSDRec;                                { ptr to next }
  660.         fsdLength:                INTEGER;                                { length of this FSD in BYTES }
  661.         fsdVersion:                INTEGER;                                { version number }
  662.         fileSystemFSID:            INTEGER;                                { file system id }
  663.         fileSystemName:            Str31;                                    { file system name }
  664.         fileSystemSpec:            FSSpec;                                    { foreign file system's FSSpec }
  665.         fileSystemGlobalsPtr:    Ptr;                                    { ptr to file system globals }
  666.         fileSystemCommProc:        FSDCommUPP;                                { communication proc with the FFS }
  667.         reserved3:                LONGINT;                                { --reserved, must be zero-- }
  668.         reserved2:                LONGINT;                                { --reserved, must be zero-- }
  669.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  670.         fsdHFSCI:                HFSCIRec;                                { HFS component interface    }
  671.         fsdDICI:                DICIRec;                                { Disk Initialization component interface }
  672.     END;
  673.     FSDRecPtr = ^FSDRec;
  674.  
  675.     FSMGetIconInfoRec = RECORD
  676.         theIcon:                ARRAY [0..31] OF LONGINT;                { The ICN# structure }
  677.         theMask:                ARRAY [0..31] OF LONGINT;                { The mask for the icon above }
  678.         whereStr:                Str255;
  679.     END;
  680.     FSMGetIconInfoRecPtr = ^FSMGetIconInfoRec;
  681.  
  682. {
  683.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  684.  }
  685.     FSMGetIconRec = RECORD
  686.         refNum:                    INTEGER;                                { target drive num or volume refnum }
  687.         iconBufferPtr:            FSMGetIconInfoRecPtr;                    { pointer to icon buffer }
  688.         requestSize:            LONGINT;                                { requested size of the icon buffer }
  689.         actualSize:                LONGINT;                                { actual size of the icon data returned }
  690.         iconType:                CHAR;                                    { kind of icon }
  691.         isEjectable:            BOOLEAN;                                { true if the device is ejectable }
  692.         driveQElemPtr:            DrvQElPtr;                                { pointer to DQE }
  693.         fileSystemSpecPtr:        FSSpecPtr;                                { pointer to foreign file system's FSSpec }
  694.         reserved1:                LONGINT;                                { --reserved, must be zero-- }
  695.     END;
  696.     FSMGetIconRecPtr = ^FSMGetIconRec;
  697.  
  698. {
  699.  *    HFS Utility routine prototypes
  700.  }
  701.  
  702. FUNCTION UTAllocateFCB(VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  703.     {$IFC NOT GENERATINGCFM}
  704.     INLINE $7000, $A824;
  705.     {$ENDC}
  706. FUNCTION UTReleaseFCB(fileRefNum: INTEGER): OSErr;
  707.     {$IFC NOT GENERATINGCFM}
  708.     INLINE $7001, $A824;
  709.     {$ENDC}
  710. FUNCTION UTLocateFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $7002, $A824;
  713.     {$ENDC}
  714. FUNCTION UTLocateNextFCB(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT; namePtr: StringPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $7003, $A824;
  717.     {$ENDC}
  718. FUNCTION UTIndexFCB(volCtrlBlockPtr: VCBPtr; VAR fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $7004, $A824;
  721.     {$ENDC}
  722. FUNCTION UTResolveFCB(fileRefNum: INTEGER; VAR fileCtrlBlockPtr: FCBRecPtr): OSErr;
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $7005, $A824;
  725.     {$ENDC}
  726. FUNCTION UTAllocateVCB(VAR sysVCBLength: INTEGER; VAR volCtrlBlockPtr: VCBPtr; addSize: INTEGER): OSErr;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $7006, $A824;
  729.     {$ENDC}
  730. FUNCTION UTAddNewVCB(driveNum: INTEGER; VAR vRefNum: INTEGER; volCtrlBlockPtr: VCBPtr): OSErr;
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $7007, $A824;
  733.     {$ENDC}
  734. FUNCTION UTDisposeVCB(volCtrlBlockPtr: VCBPtr): OSErr;
  735.     {$IFC NOT GENERATINGCFM}
  736.     INLINE $7008, $A824;
  737.     {$ENDC}
  738. FUNCTION UTLocateVCBByRefNum(refNum: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  739.     {$IFC NOT GENERATINGCFM}
  740.     INLINE $7009, $A824;
  741.     {$ENDC}
  742. FUNCTION UTLocateVCBByName(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  743.     {$IFC NOT GENERATINGCFM}
  744.     INLINE $700A, $A824;
  745.     {$ENDC}
  746. FUNCTION UTLocateNextVCB(namePtr: StringPtr; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  747.     {$IFC NOT GENERATINGCFM}
  748.     INLINE $700B, $A824;
  749.     {$ENDC}
  750. FUNCTION UTAllocateWDCB(paramBlock: WDPBPtr): OSErr;
  751.     {$IFC NOT GENERATINGCFM}
  752.     INLINE $700C, $A824;
  753.     {$ENDC}
  754. FUNCTION UTReleaseWDCB(wdRefNum: INTEGER): OSErr;
  755.     {$IFC NOT GENERATINGCFM}
  756.     INLINE $700D, $A824;
  757.     {$ENDC}
  758. FUNCTION UTResolveWDCB(procID: LONGINT; wdIndex: INTEGER; wdRefNum: INTEGER; VAR wdCtrlBlockPtr: WDCBRecPtr): OSErr;
  759.     {$IFC NOT GENERATINGCFM}
  760.     INLINE $700E, $A824;
  761.     {$ENDC}
  762. FUNCTION UTFindDrive(driveNum: INTEGER; VAR driveQElementPtr: DrvQElPtr): OSErr;
  763.     {$IFC NOT GENERATINGCFM}
  764.     INLINE $700F, $A824;
  765.     {$ENDC}
  766. FUNCTION UTAdjustEOF(fileRefNum: INTEGER): OSErr;
  767.     {$IFC NOT GENERATINGCFM}
  768.     INLINE $7010, $A824;
  769.     {$ENDC}
  770. FUNCTION UTSetDefaultVol(nodeHint: LONGINT; dirID: LONGINT; refNum: INTEGER): OSErr;
  771.     {$IFC NOT GENERATINGCFM}
  772.     INLINE $7011, $A824;
  773.     {$ENDC}
  774. FUNCTION UTGetDefaultVol(paramBlock: WDPBPtr): OSErr;
  775.     {$IFC NOT GENERATINGCFM}
  776.     INLINE $7012, $A824;
  777.     {$ENDC}
  778. FUNCTION UTEjectVol(volCtrlBlockPtr: VCBPtr): OSErr;
  779.     {$IFC NOT GENERATINGCFM}
  780.     INLINE $702B, $A824;
  781.     {$ENDC}
  782. FUNCTION UTCheckWDRefNum(wdRefNum: INTEGER): OSErr;
  783.     {$IFC NOT GENERATINGCFM}
  784.     INLINE $7013, $A824;
  785.     {$ENDC}
  786. FUNCTION UTCheckFileRefNum(fileRefNum: INTEGER): OSErr;
  787.     {$IFC NOT GENERATINGCFM}
  788.     INLINE $7014, $A824;
  789.     {$ENDC}
  790. FUNCTION UTCheckVolRefNum(vRefNum: INTEGER): OSErr;
  791.     {$IFC NOT GENERATINGCFM}
  792.     INLINE $7015, $A824;
  793.     {$ENDC}
  794. FUNCTION UTCheckPermission(volCtrlBlockPtr: VCBPtr; VAR modByte: INTEGER; fileNum: LONGINT; paramBlock: ParmBlkPtr): OSErr;
  795.     {$IFC NOT GENERATINGCFM}
  796.     INLINE $7016, $A824;
  797.     {$ENDC}
  798. FUNCTION UTCheckVolOffline(vRefNum: INTEGER): OSErr;
  799.     {$IFC NOT GENERATINGCFM}
  800.     INLINE $7017, $A824;
  801.     {$ENDC}
  802. FUNCTION UTCheckVolModifiable(vRefNum: INTEGER): OSErr;
  803.     {$IFC NOT GENERATINGCFM}
  804.     INLINE $7018, $A824;
  805.     {$ENDC}
  806. FUNCTION UTCheckFileModifiable(fileRefNum: INTEGER): OSErr;
  807.     {$IFC NOT GENERATINGCFM}
  808.     INLINE $7019, $A824;
  809.     {$ENDC}
  810. FUNCTION UTCheckDirBusy(volCtrlBlockPtr: VCBPtr; dirID: LONGINT): OSErr;
  811.     {$IFC NOT GENERATINGCFM}
  812.     INLINE $701A, $A824;
  813.     {$ENDC}
  814. FUNCTION UTParsePathname(VAR volNamelength: INTEGER; namePtr: StringPtr): OSErr;
  815.     {$IFC NOT GENERATINGCFM}
  816.     INLINE $701B, $A824;
  817.     {$ENDC}
  818. FUNCTION UTGetPathComponentName(parseRec: ParsePathRecPtr): OSErr;
  819.     {$IFC NOT GENERATINGCFM}
  820.     INLINE $701C, $A824;
  821.     {$ENDC}
  822. FUNCTION UTDetermineVol(paramBlock: ParmBlkPtr; VAR status: INTEGER; VAR moreMatches: INTEGER; VAR vRefNum: INTEGER; VAR volCtrlBlockPtr: VCBPtr): OSErr;
  823.     {$IFC NOT GENERATINGCFM}
  824.     INLINE $701D, $A824;
  825.     {$ENDC}
  826. FUNCTION UTGetBlock(refNum: INTEGER; log2PhyProc: UNIV Ptr; blockNum: LONGINT; gbOption: INTEGER; VAR buffer: Ptr): OSErr;
  827.     {$IFC NOT GENERATINGCFM}
  828.     INLINE $701F, $A824;
  829.     {$ENDC}
  830. FUNCTION UTReleaseBlock(buffer: Ptr; rbOption: INTEGER): OSErr;
  831.     {$IFC NOT GENERATINGCFM}
  832.     INLINE $7020, $A824;
  833.     {$ENDC}
  834. FUNCTION UTFlushCache(refNum: INTEGER; fcOption: INTEGER): OSErr;
  835.     {$IFC NOT GENERATINGCFM}
  836.     INLINE $7021, $A824;
  837.     {$ENDC}
  838. FUNCTION UTMarkDirty(buffer: Ptr): OSErr;
  839.     {$IFC NOT GENERATINGCFM}
  840.     INLINE $7023, $A824;
  841.     {$ENDC}
  842. FUNCTION UTTrashVolBlocks(volCtrlBlockPtr: VCBPtr): OSErr;
  843.     {$IFC NOT GENERATINGCFM}
  844.     INLINE $7024, $A824;
  845.     {$ENDC}
  846. FUNCTION UTTrashFileBlocks(volCtrlBlockPtr: VCBPtr; fileNum: LONGINT): OSErr;
  847.     {$IFC NOT GENERATINGCFM}
  848.     INLINE $7025, $A824;
  849.     {$ENDC}
  850. FUNCTION UTTrashBlocks(beginPosition: LONGINT; byteCount: LONGINT; volCtrlBlockPtr: VCBPtr; fileRefNum: INTEGER; tbOption: INTEGER): OSErr;
  851.     {$IFC NOT GENERATINGCFM}
  852.     INLINE $7026, $A824;
  853.     {$ENDC}
  854. FUNCTION UTCacheReadIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  855.     {$IFC NOT GENERATINGCFM}
  856.     INLINE $7027, $A824;
  857.     {$ENDC}
  858. FUNCTION UTCacheWriteIP(log2PhyProc: UNIV Ptr; filePosition: LONGINT; ioBuffer: Ptr; fileRefNum: INTEGER; reqCount: LONGINT; VAR actCount: LONGINT; cacheOption: INTEGER): OSErr;
  859.     {$IFC NOT GENERATINGCFM}
  860.     INLINE $7028, $A824;
  861.     {$ENDC}
  862. FUNCTION UTBlockInFQHashP(vRefNum: INTEGER; diskBlock: LONGINT): OSErr;
  863.     {$IFC NOT GENERATINGCFM}
  864.     INLINE $702C, $A824;
  865.     {$ENDC}
  866. {
  867.  *    File System Manager call prototypes
  868.  }
  869. FUNCTION InstallFS(fsdPtr: FSDRecPtr): OSErr;
  870. FUNCTION RemoveFS(fsid: INTEGER): OSErr;
  871. FUNCTION SetFSInfo(fsid: INTEGER; bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  872. FUNCTION GetFSInfo(selector: INTEGER; key: INTEGER; VAR bufSize: INTEGER; fsdPtr: FSDRecPtr): OSErr;
  873. FUNCTION InformFSM(theMessage: INTEGER; paramBlock: UNIV Ptr): OSErr;
  874. FUNCTION InformFFS(fsid: INTEGER; paramBlock: UNIV Ptr): OSErr;
  875.  
  876. {$ALIGN RESET}
  877. {$POP}
  878.  
  879. {$SETC UsingIncludes := FSMIncludes}
  880.  
  881. {$ENDC} {__FSM__}
  882.  
  883. {$IFC NOT UsingIncludes}
  884.  END.
  885. {$ENDC}
  886.